home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Interactive Reference Guide / C-C++ Interactive Reference Guide.iso / c_ref / csource4 / 277_01 / hpgl.c < prev    next >
Text File  |  1988-11-15  |  28KB  |  1,294 lines
  1.  
  2. /*                             *
  3.  * HPGL-Clib Version 1.0                *
  4.  * Hewlett Packard Graphics Language 'C' Library     *
  5.  * (c) Copyright 1988, TerrAqueous Software        *
  6.  */
  7.  
  8. /* Disclaimer:                        *
  9.  * TerrAqueous Software makes no expressed or implied    *
  10.  * warranties of any kind regarding this software. In    *
  11.  * no event will TerrAqueous Software be liable for any    *
  12.  * damages or losses arising out of use of this soft-    *
  13.  * ware.                        *
  14.  */
  15.  
  16. /* Software Developers Rights:                *
  17.  * TerrAqueous Software does not require royalties on    *
  18.  * generated applications using HPGL-Clib           *
  19.  */
  20.  
  21. /* HPGL-Clib is SHAREWARE, you are encouraged to copy   * 
  22.  * and share this program with other users, on the      *
  23.  * condition that no fee or consideration is charged,   *
  24.  * and that this notice is not removed.                 *
  25.  *                            *
  26.  * COMMERCIAL USERS: A $49 license fee is required if   *
  27.  * used in a place of business or incorporated into     *
  28.  * another product.                    *
  29.  *                            *
  30.  * PRIVATE USERS: If you are using this program and     *
  31.  * find it of value, your contribution ($49 suggested)  *
  32.  * will be appreciated.                    *
  33.  *                            *
  34.  * This Software is USER SUPPORTED and your enhance-    *
  35.  * ments sent to us are encouraged. Software sent to us *
  36.  * will become the property of TerrAqueous Software.    *
  37.  *                            *
  38.  * Your license fee or contribution will get you the    *
  39.  * most recent version of HPGL-Clib and keep you on our *
  40.  * mailing list of announcements for our latest         *
  41.  * products.
  42.  *                            *
  43.  * TerrAqueous Software                    *
  44.  * 19515 FM 149, # 40, Houston, Texas 77070        *
  45.  *                            *
  46.  * Software that gets you where your going!        *
  47.  */
  48.  
  49. #include <stdio.h>
  50. #include "hpgl.h"
  51.  
  52. /* level 1 calls                     *
  53.  * The following is the lowest level of the hpgl     *
  54.  * library calls, those which most closely follow    *
  55.  * the HP-GL two letter mnemonic instruction syntax.    *
  56.  * These functions are shown in alphabetical order of   *
  57.  * the two letter mnemonic. A plotter reference manual  *
  58.  * such as the HP7470A Interfacing and Programming      *
  59.  * Manual is recommended.
  60.  *                            *
  61.  * micro488 notes the use of a IO_tech MICRO488 Bus     *
  62.  * Controller, a serial to GPIB converter. If this      *
  63.  * device is not in use, make certain that this char    *
  64.  * pointer passes a NULL.
  65.  */
  66.  
  67. /* AA - arc absolute, plotter units */
  68. void hpgl_arc_abs_pu(fp, x, y, arc_angle, chord_angle, micro488)
  69. FILE *fp;
  70. int x, y, arc_angle, chord_angle;
  71. char *micro488;
  72. {
  73.     rewind(fp);
  74.     if(*micro488 != NULL)
  75.         fprintf(fp,"%s",micro488);
  76.     fprintf(fp,"AA%d,%d,%d,%d;",x, y, arc_angle, chord_angle);
  77.     if(*micro488 != NULL)
  78.         fprintf(fp,"\n");
  79. }
  80.  
  81. /* AA - arc absolute, user units */
  82. void hpgl_arc_abs_uu(fp, x, y, arc_angle, chord_angle, micro488)
  83. FILE *fp;
  84. int arc_angle, chord_angle;
  85. float x, y;
  86. char *micro488;
  87. {
  88.     rewind(fp);
  89.     if(*micro488 != NULL)
  90.         fprintf(fp,"%s",micro488);
  91.     fprintf(fp,"AA%f,%f,%d,%d;",x, y, arc_angle, chord_angle);
  92.     if(*micro488 != NULL)
  93.         fprintf(fp,"\n");
  94. }
  95.  
  96. /* AR - arc relative, plotter units */
  97. void hpgl_arc_rel_pu(fp, x, y, arc_angle, chord_angle, micro488)
  98. FILE *fp;
  99. int x, y, arc_angle, chord_angle;
  100. char *micro488;
  101. {
  102.     rewind(fp);
  103.     if(*micro488 != NULL)
  104.         fprintf(fp,"%s",micro488);
  105.     fprintf(fp, "AR%d,%d,%d,%d;",x, y, arc_angle, chord_angle);
  106.     if(*micro488 != NULL)
  107.         fprintf(fp,"\n");
  108. }
  109.  
  110. /* AR - arc relative, user units */
  111. void hpgl_arc_rel_uu(fp, x, y, arc_angle, chord_angle, micro488)
  112. FILE *fp;
  113. int arc_angle, chord_angle;
  114. float x, y;
  115. char *micro488;
  116. {
  117.     rewind(fp);
  118.     if(*micro488 != NULL)
  119.         fprintf(fp,"%s",micro488);
  120.     fprintf(fp, "AR%f,%f,%d,%d;",x, y, arc_angle, chord_angle);
  121.     if(*micro488 != NULL)
  122.         fprintf(fp,"\n");
  123. }
  124.  
  125. /* BP - beep, from hp9111a graphics tablet manual */
  126. void graph_tab_beep(fp, frequency, duration, amplitude, micro488)
  127. FILE *fp;
  128. int frequency, duration, amplitude;
  129. char *micro488;
  130. {
  131.     rewind(fp);
  132.     if(*micro488 != NULL)
  133.         fprintf(fp,"%s",micro488);
  134.     fprintf(fp,"BP%d,%d,%d;",frequency, duration, amplitude);
  135.     if(*micro488 != NULL)
  136.         fprintf(fp,"\n");
  137. }
  138.  
  139. /* CA - designate alternative character set */
  140. void hpgl_char_set(fp, n, micro488)
  141. FILE *fp;
  142. int n;
  143. char *micro488;
  144. {
  145.     rewind(fp); 
  146.     if(*micro488 != NULL)
  147.         fprintf(fp,"%s",micro488);
  148.     fprintf(fp,"CA%d;",n);
  149.     if(*micro488 != NULL)
  150.         fprintf(fp,"\n");
  151. }
  152.  
  153. /* CI - circle */
  154. void hpgl_circle(fp, radius, chord_angle, micro488)
  155. FILE *fp;
  156. int radius, chord_angle;
  157. char *micro488;
  158. {
  159.     rewind(fp);
  160.     if(*micro488 != NULL)
  161.         fprintf(fp,"%s",micro488);
  162.     fprintf(fp,"CI%d,%d;",radius,chord_angle);
  163.     if(*micro488 != NULL)
  164.         fprintf(fp,"\n");
  165. }
  166.  
  167. /* CP - character plot */
  168. void hpgl_char_plot(fp, spaces, lines, micro488)
  169. FILE *fp;
  170. float spaces, lines;
  171. char *micro488;
  172. {
  173.     rewind(fp);
  174.     if(*micro488 != NULL)
  175.         fprintf(fp,"%s",micro488);
  176.     fprintf(fp,"CP%f,%f;",spaces,lines);
  177.     if(*micro488 != NULL)
  178.         fprintf(fp,"\n");
  179. }
  180.  
  181. /* CR - cursor rate, from hp9111a graphics tablet manual */
  182. void graph_tab_cursor_rate(fp, rate, micro488)
  183. FILE *fp;
  184. int rate;
  185. char *micro488;
  186. {
  187.     rewind(fp);
  188.     if(*micro488 != NULL)
  189.         fprintf(fp,"%s",micro488);
  190.     fprintf(fp,"CR%d;",rate);
  191.     if(*micro488 != NULL)
  192.         fprintf(fp,"\n");
  193. }
  194.  
  195. /* CS - designate standard character set */
  196. void hpgl_stand_char(fp, m, micro488)
  197. FILE *fp;
  198. int m;
  199. char *micro488;
  200. {
  201.     rewind(fp);
  202.     if(*micro488 != NULL)
  203.         fprintf(fp,"%s",micro488);
  204.     fprintf(fp,"CS%d;",m);
  205.     if(*micro488 != NULL)
  206.         fprintf(fp,"\n");
  207. }
  208.  
  209. /* DI - absolute direction */
  210. void hpgl_abs_dir(fp, run, rise, micro488)
  211. FILE *fp;
  212. float run, rise;
  213. char *micro488;
  214. {
  215.     rewind(fp);
  216.     if(*micro488 != NULL)
  217.         fprintf(fp,"%s",micro488);
  218.     fprintf(fp,"DI%f,%f;",run,rise);
  219.     if(*micro488 != NULL)
  220.         fprintf(fp,"\n");
  221. }
  222.  
  223. /* DR - relative direction */
  224. void hpgl_rel_dir(fp, run, rise, micro488)
  225. FILE *fp;
  226. float run, rise;
  227. char *micro488;
  228. {
  229.     rewind(fp);
  230.     if(*micro488 != NULL)
  231.         fprintf(fp,"%s",micro488);
  232.     fprintf(fp,"DR%f,%f;",run, rise);
  233.     if(*micro488 != NULL)
  234.         fprintf(fp,"\n");
  235. }
  236.  
  237. /* DT - define terminator */
  238. void hpgl_def_term(fp, t, micro488)
  239. FILE *fp;
  240. int t; /* t must be ASCII character 1 - 127 */
  241. char *micro488;
  242. {
  243.     rewind(fp);
  244.     if(*micro488 != NULL)
  245.         fprintf(fp,"%s",micro488);
  246.     fprintf(fp,"DT%d;",t);
  247.     if(*micro488 != NULL)
  248.         fprintf(fp,"\n");
  249. }
  250.  
  251. /* EA - absolute rectangle, plotter units, from Fujitsu FPG-310 manual */
  252. void hpgl_rectangle_abs_pu(fp, x, y, micro488)
  253. FILE *fp;
  254. int x, y;
  255. char *micro488;
  256. {
  257.     rewind(fp);
  258.     if(*micro488 != NULL)
  259.         fprintf(fp,"%s",micro488);
  260.     fprintf(fp,"EA%d,%d;",x, y);
  261.     if(*micro488 != NULL)
  262.         fprintf(fp,"\n");
  263. }
  264.  
  265. /* EA - absolute rectangle, user units, from Fujitsu FPG-310 manual */
  266. void hpgl_rectangle_abs_uu(fp, x, y, micro488)
  267. FILE *fp;
  268. float x, y;
  269. char *micro488;
  270. {
  271.     rewind(fp);
  272.     if(*micro488 != NULL)
  273.         fprintf(fp,"%s",micro488);
  274.     fprintf(fp,"EA%f,%f;",x, y);
  275.     if(*micro488 != NULL)
  276.         fprintf(fp,"\n");
  277. }
  278.  
  279. /* ER - relative rectangle, plotter units, from Fujitsu FPG-310 manual */
  280. void hpgl_rectangle_rel_pu(fp, x, y, micro488)
  281. FILE *fp;
  282. int x, y;
  283. char *micro488;
  284. {
  285.     rewind(fp);
  286.     if(*micro488 != NULL)
  287.         fprintf(fp,"%s",micro488);
  288.     fprintf(fp,"ER%d,%d;",x, y);
  289.     if(*micro488 != NULL)
  290.         fprintf(fp,"\n");
  291. }
  292.  
  293. /* ER - relative rectangle, user units, from Fujitsu FPG-310 manual */
  294. void hpgl_rectangle_rel_uu(fp, x, y, micro488)
  295. FILE *fp;
  296. float x, y;
  297. char *micro488;
  298. {
  299.     rewind(fp);
  300.     if(*micro488 != NULL)
  301.         fprintf(fp,"%s",micro488);
  302.     fprintf(fp,"ER%f,%f;",x, y);
  303.     if(*micro488 != NULL)
  304.         fprintf(fp,"\n");
  305. }
  306.  
  307. /* EW - sector form, plotter units, from Fujitsu FPG-310 manual */
  308. void hpgl_sector_form_pu(fp, r, delta_theta, theta, phi, micro488)
  309. FILE *fp;
  310. int r, delta_theta, theta, phi;
  311. char *micro488;
  312. {
  313.     rewind(fp);
  314.     if(*micro488 != NULL)
  315.         fprintf(fp,"%s",micro488);
  316.     fprintf(fp,"EW%d,%d,%d,%d;",r, delta_theta, theta, phi);
  317.     if(*micro488 != NULL)
  318.         fprintf(fp,"\n");
  319. }
  320.  
  321. /* EW - sector form, user units, from Fujitsu FPG-310 manual */
  322. void hpgl_sector_form_uu(fp, r, delta_theta, theta, phi, micro488)
  323. FILE *fp;
  324. float r; 
  325. int delta_theta, theta, phi;
  326. char *micro488;
  327. {
  328.     rewind(fp);
  329.     if(*micro488 != NULL)
  330.         fprintf(fp,"%s",micro488);
  331.     fprintf(fp,"EW%f,%d,%d,%d;",r, delta_theta, theta, phi);
  332.     if(*micro488 != NULL)
  333.         fprintf(fp,"\n");
  334. }
  335.  
  336. /* FT - hatching pattern, plotter units, form Fujitsu FPG-310 manual */
  337. void hpgl_hatch_pat_pu(fp, n, d, theta, micro488)
  338. FILE *fp;
  339. int n, d, theta;
  340. char *micro488;
  341. {
  342.     rewind(fp);
  343.     if(*micro488 != NULL)
  344.         fprintf(fp,"%s",micro488);
  345.     fprintf(fp,"FT%d,%d,%d;",n, d, theta);
  346.     if(*micro488 != NULL)
  347.         fprintf(fp,"\n");
  348. }
  349.  
  350. /* FT - hatching pattern, user units, form Fujitsu FPG-310 manual */
  351. void hpgl_hatch_pat_uu(fp, n, d, theta, micro488)
  352. FILE *fp;
  353. float d;
  354. int n, theta;
  355. char *micro488;
  356. {
  357.     rewind(fp);
  358.     if(*micro488 != NULL)
  359.         fprintf(fp,"%s",micro488);
  360.     fprintf(fp,"FT%d,%f,%d;",n, d, theta);
  361.     if(*micro488 != NULL)
  362.         fprintf(fp,"\n");
  363. }
  364.  
  365. /* IM - input mask */
  366. void hpgl_in_mask(fp, e_mask, s_mask, p_mask, micro488)
  367. FILE *fp;
  368. int e_mask, s_mask, p_mask; /* default is 233, 0, 0 */
  369. char *micro488;
  370. {
  371.     rewind(fp);
  372.     if(*micro488 != NULL)
  373.         fprintf(fp,"%s",micro488);
  374.     fprintf(fp,"IM%d,%d,%d;",e_mask, s_mask, p_mask);
  375.     if(*micro488 != NULL)
  376.         fprintf(fp,"\n");
  377. }
  378.  
  379. /* IP - input p1 and p2 */
  380. void hpgl_in_p1_p2(fp, p1x, p1y, p2x, p2y, micro488)
  381. FILE *fp;
  382. int p1x, p1y, p2x, p2y;
  383. char *micro488;
  384. {
  385.     rewind(fp);
  386.     if(*micro488 != NULL)
  387.         fprintf(fp,"%s",micro488);
  388.     fprintf(fp,"IP%d,%d,%d,%d;",p1x, p1y, p2x, p2y); 
  389.     if(*micro488 != NULL)
  390.         fprintf(fp,"\n");
  391. }
  392.  
  393. /* IW - input window */
  394. void hpgl_in_wind(fp, x_ll, y_ll, x_ur, y_ur, micro488)
  395. FILE *fp;
  396. int x_ll, y_ll, x_ur, y_ur;
  397. char *micro488;
  398. {
  399.     rewind(fp);
  400.     if(*micro488 != NULL)
  401.         fprintf(fp,"%s",micro488);
  402.     fprintf(fp,"IW%d,%d,%d,%d;",x_ll, y_ll, x_ur, y_ur);
  403.     if(*micro488 != NULL)
  404.         fprintf(fp,"\n");
  405. }
  406.  
  407. /* LB - label */
  408. void hpgl_label(fp,text, t, micro488)
  409. FILE *fp;
  410. char text[], t; /* default is the defined ETX for terminator */ 
  411. char *micro488;
  412. {
  413.     rewind(fp);
  414.     if(*micro488 != NULL)
  415.         fprintf(fp,"%s",micro488);
  416.     fprintf(fp,"LB%s%c",text, t);
  417.     if(*micro488 != NULL)
  418.         fprintf(fp,"\n");
  419. }
  420.  
  421. /* LT - line type */
  422. void hpgl_line_type(fp, pat_num, pat_len, micro488)
  423. FILE *fp;
  424. int pat_num, pat_len;
  425. char *micro488;
  426. {
  427.     rewind(fp);
  428.     if(*micro488 != NULL)
  429.         fprintf(fp,"%s",micro488);
  430.     fprintf(fp,"LT%d,%d;",pat_num, pat_len);
  431.     if(*micro488 != NULL)
  432.         fprintf(fp,"\n");
  433. }
  434.  
  435. /* OA - output actual position and pen status */
  436. void hpgl_pos_pen
  437. (fp, x, y, p, micro488)
  438. FILE *fp;
  439. int *x, *y, *p;
  440. char *micro488;
  441. {
  442.     char buf[80];
  443.     char enter488[10];
  444.     int i;
  445.  
  446.     for(i=0; i<80; i++) buf[i] = NULL;
  447.     rewind(fp);
  448.     if(*micro488 != NULL)
  449.         fprintf(fp,"%s",micro488);
  450.     fprintf(fp,"OA;");
  451.     if(*micro488 != NULL) {
  452.         out_enter(micro488, enter488);
  453.         fprintf(fp,"\n%s\n",enter488);
  454.     }
  455.     rewind(fp);
  456.     fgets(buf,80,fp);
  457.     sscanf(buf,"%d%*c%d%*c%d%*c",x, y, p);
  458. }
  459.  
  460. /* OC - output commanded position and pen status, plotter units */
  461. void hpgl_out_pos_pen_pu(fp, x, y, p, micro488)
  462. FILE *fp;
  463. int *x, *y, *p;
  464. char *micro488;
  465. {
  466.     char buf[80];
  467.     char enter488[10];
  468.  
  469.     rewind(fp);
  470.     if(*micro488 != NULL)
  471.         fprintf(fp,"%s",micro488);
  472.     fprintf(fp,"OC;");
  473.     if(*micro488 != NULL) {
  474.         out_enter(micro488, enter488);
  475.         fprintf(fp,"\n%s\n",enter488);
  476.     }
  477.     rewind(fp);
  478.     fgets(buf,80,fp);
  479.     sscanf(buf,"%d%*c%d%*c%d%*c",x, y, p);
  480. }
  481.  
  482. /* OC - output commanded position and pen status, user units */
  483. void hpgl_out_pos_pen_uu(fp, x, y, p, micro488)
  484. FILE *fp;
  485. float *x, *y, *p;
  486. char *micro488;
  487. {
  488.     char buf[80];
  489.     char enter488[10];
  490.  
  491.     rewind(fp);
  492.     if(*micro488 != NULL)
  493.         fprintf(fp,"%s",micro488);
  494.     fprintf(fp,"OC;");
  495.     if(*micro488 != NULL) {
  496.         out_enter(micro488, enter488);
  497.         fprintf(fp,"\n%s\n",enter488);
  498.     }
  499.     rewind(fp);
  500.     fgets(buf,80,fp);
  501.     sscanf(buf,"%f%*c%f%*c%f%*c",x, y, p);
  502. }
  503.  
  504. /* OD - output digitized point and pen status */
  505. void hpgl_out_pt_pen(fp, x, y, p, micro488)
  506. FILE *fp;
  507. int *x, *y, *p;
  508. char *micro488;
  509. {
  510.     char buf[80];
  511.     char enter488[10];
  512.  
  513.     rewind(fp);
  514.     if(*micro488 != NULL)
  515.         fprintf(fp,"%s",micro488);
  516.     fprintf(fp,"OD;");
  517.     if(*micro488 != NULL) {
  518.         out_enter(micro488, enter488);
  519.         fprintf(fp,"\n%s\n",enter488);
  520.     }
  521.     rewind(fp);
  522.     fgets(buf,80,fp);
  523.     sscanf(buf,"%d%*c%d%*c%d%*c",x, y, p);
  524. }
  525.  
  526. /* OE - output error instruction */
  527. int hpgl_out_error(fp, micro488)
  528. FILE *fp;
  529. char *micro488;
  530. {
  531.     char buf[80];
  532.     char enter488[10];
  533.     int error=0;
  534.  
  535.     rewind(fp);
  536.     if(*micro488 != NULL)
  537.         fprintf(fp,"%s",micro488);
  538.     fprintf(fp,"OE;");
  539.     if(*micro488 != NULL) {
  540.         out_enter(micro488, enter488);
  541.         fprintf(fp,"\n%s\n",enter488);
  542.     }
  543.     rewind(fp);
  544.     fgets(buf,80,fp);
  545.     sscanf(buf,"%d%*c",&error);
  546.     return(error);
  547. }
  548.  
  549. /* OF - output factors */
  550. void hpgl_out_fac(fp, x_fac, y_fac, micro488)
  551. FILE *fp;
  552. int *x_fac, *y_fac;
  553. char *micro488;
  554. {
  555.     char buf[80];
  556.     char enter488[10];
  557.  
  558.     rewind(fp);
  559.     if(*micro488 != NULL)
  560.         fprintf(fp,"%s",micro488);
  561.     fprintf(fp,"OF;");
  562.     if(*micro488 != NULL) {
  563.         out_enter(micro488, enter488);
  564.         fprintf(fp,"\n%s\n",enter488);
  565.     }
  566.     rewind(fp);
  567.     fgets(buf,80,fp);
  568.     sscanf(buf,"%d%*c%d%*c",x_fac, y_fac);
  569. }
  570.  
  571. /* OH - output effective drawing range of current paper type, from Fujitsu
  572.    FPG-310 manual */
  573. void hpgl_out_paper(fp, x_ll, y_ll, x_ur, y_ur, micro488)
  574. FILE *fp;
  575. int *x_ll, *y_ll, *x_ur, *y_ur;
  576. char *micro488;
  577. {
  578.     char buf[80];
  579.     char enter488[10];
  580.  
  581.     rewind(fp);
  582.     if(*micro488 != NULL)
  583.         fprintf(fp,"%s",micro488);
  584.     fprintf(fp,"OH;");
  585.     if(*micro488 != NULL) {
  586.         out_enter(micro488, enter488);
  587.         fprintf(fp,"\n%s\n",enter488);
  588.     }
  589.     rewind(fp);
  590.     fgets(buf,80,fp);
  591.     sscanf(buf,"%d%*c%d%*c%d%*c%d%*c",x_ll, y_ll, x_ur, y_ur);
  592. }
  593.  
  594. /* OI - output identification */
  595. void hpgl_out_id(fp, id, micro488)
  596. FILE *fp;
  597. char id[];
  598. char *micro488;
  599. {
  600.     char buf[80];
  601.     char enter488[10];
  602.  
  603.     rewind(fp);
  604.     if(*micro488 != NULL)
  605.         fprintf(fp,"%s",micro488);
  606.     fprintf(fp,"OI;");
  607.     if(*micro488 != NULL) {
  608.         out_enter(micro488, enter488);
  609.         fprintf(fp,"\n%s\n",enter488);
  610.     }
  611.     rewind(fp);
  612.     fgets(buf,80,fp);
  613.     sscanf(buf,"%s%*c",id);
  614. }
  615.  
  616. /* OK - output key, from hp9111a graphics tablet manual */
  617. int graph_tab_out_key(fp, micro488)
  618. FILE *fp;
  619. char *micro488;
  620. {
  621.     char buf[80];
  622.     char enter488[10];
  623.     int key;
  624.  
  625.     rewind(fp);
  626.     if(*micro488 != NULL)
  627.         fprintf(fp,"%s",micro488);
  628.     fprintf(fp,"OK;");
  629.     if(*micro488 != NULL) {
  630.         out_enter(micro488, enter488);
  631.         fprintf(fp,"\n%s\n",enter488);
  632.     }
  633.     rewind(fp);
  634.     fgets(buf,80,fp);
  635.     sscanf(buf,"%d%*c",&key);
  636.     return(key);
  637. }
  638.  
  639. /* OO - output options */
  640. void hpgl_out_opt(fp, a, pen_sel, c, d, arc_cir, e, f, g, micro488)
  641. FILE *fp;
  642. int *a, *pen_sel, *c, *d, *arc_cir, *e,  *f, *g;
  643. char *micro488;
  644. {
  645.     char buf[80];
  646.     char enter488[10];
  647.  
  648.     rewind(fp);
  649.     if(*micro488 != NULL)
  650.         fprintf(fp,"%s",micro488);
  651.     fprintf(fp,"OO;");
  652.     if(*micro488 != NULL) {
  653.         out_enter(micro488, enter488);
  654.         fprintf(fp,"\n%s\n",enter488);
  655.     }
  656.     rewind(fp);
  657.     fgets(buf,80,fp);
  658.     sscanf(buf,"%d%*c%d%*c%d%*c%d%*c%d%*c%d%*c%d%*c%d%*c",
  659.     a, pen_sel, c, d, arc_cir, e, f, g);
  660. }
  661.  
  662. /* OP - output p1 and p2 */
  663. void hpgl_out_p1_p2(fp, p1x, p1y, p2x, p2y, micro488)
  664. FILE *fp;
  665. int *p1x, *p1y, *p2x, *p2y;
  666. char *micro488;
  667. {
  668.     char buf[80];
  669.     char enter488[10];
  670.  
  671.     rewind(fp);
  672.     if(*micro488 != NULL)
  673.         fprintf(fp,"%s",micro488);
  674.     fprintf(fp,"OP;");
  675.     if(*micro488 != NULL) {
  676.         out_enter(micro488, enter488);
  677.         fprintf(fp,"\n%s\n",enter488);
  678.     }
  679.     rewind(fp);
  680.     fgets(buf,80,fp);
  681.     sscanf(buf,"%d%*c%d%*c%d%*c%d%*c",p1x,p1y,p2x,p2y);
  682. }
  683.  
  684. /* OR - output resolution, from hp9111a graphics tablet manual */
  685. void graph_tab_out_resolution(fp, x, y, micro488)
  686. FILE *fp;
  687. float *x, *y;
  688. char *micro488;
  689. {
  690.     char buf[80];
  691.     char enter488[10];
  692.  
  693.     rewind(fp);
  694.     if(*micro488 != NULL)
  695.         fprintf(fp,"%s",micro488);
  696.     fprintf(fp,"OR;");
  697.     if(*micro488 != NULL) {
  698.         out_enter(micro488, enter488);
  699.         fprintf(fp,"\n%s\n",enter488);
  700.     }
  701.     rewind(fp);
  702.     fgets(buf,80,fp);
  703.     sscanf(buf,"%f%*c%f%*c",x, y);
  704. }
  705.  
  706. /* OS - output status */
  707. int hpgl_status(fp, micro488)
  708. FILE *fp;
  709. char *micro488;
  710. {
  711.     char buf[80];
  712.     char enter488[10];
  713.     int status=0;
  714.  
  715.     rewind(fp);
  716.     if(*micro488 != NULL)
  717.         fprintf(fp,"%s",micro488);
  718.     fprintf(fp,"OS;");
  719.     if(*micro488 != NULL) {
  720.         out_enter(micro488, enter488);
  721.         fprintf(fp,"\n%s\n",enter488);
  722.     }
  723.     rewind(fp);
  724.     fgets(buf,80,fp);
  725.     sscanf(buf,"%d%*c",&status);
  726.     return(status);
  727. }
  728.  
  729. /* OW - output window */
  730. void hpgl_out_wind(fp, x_ll, y_ll, x_ur, y_ur, micro488)
  731. FILE *fp;
  732. int *x_ll, *y_ll, *x_ur, *y_ur;
  733. char *micro488;
  734. {
  735.     char buf[80];
  736.     char enter488[10];
  737.  
  738.     rewind(fp);
  739.     if(*micro488 != NULL)
  740.         fprintf(fp,"%s",micro488);
  741.     fprintf(fp,"OW;");
  742.     if(*micro488 != NULL) {
  743.         out_enter(micro488, enter488);
  744.         fprintf(fp,"\n%s\n",enter488);
  745.     }
  746.     rewind(fp);
  747.     fgets(buf,80,fp);
  748.     sscanf(buf,"%d%*c%d%*c%d%*c%d%*c",x_ll, y_ll, x_ur, y_ur);
  749. }
  750.  
  751. /* PA - plot absolute plotter units */
  752. void hpgl_plt_abs_pu(fp, x, y, micro488)
  753. FILE *fp;
  754. int x, y;
  755. char *micro488;
  756. {
  757.     rewind(fp);
  758.     if(*micro488 != NULL)
  759.         fprintf(fp,"%s",micro488);
  760.     fprintf(fp,"PA%d,%d;",x, y);
  761.     if(*micro488 != NULL)
  762.         fprintf(fp,"\n");
  763. }
  764.  
  765. /* PA - plot absolute  user units */
  766. void hpgl_plt_abs_uu(fp, x, y, micro488)
  767. FILE *fp;
  768. float x, y;
  769. char *micro488;
  770. {
  771.     rewind(fp);
  772.     if(*micro488 != NULL)
  773.         fprintf(fp,"%s",micro488);
  774.     fprintf(fp,"PA%.4f,%.4f;",x, y);
  775.     if(*micro488 != NULL)
  776.         fprintf(fp,"\n");
  777. }
  778.  
  779. /* PD - pen down */
  780. void hpgl_pen_dwn(fp, x, y, micro488)
  781. FILE *fp;
  782. int x, y;
  783. char *micro488;
  784. {
  785.     rewind(fp);
  786.     if(*micro488 != NULL)
  787.         fprintf(fp,"%s",micro488);
  788.     fprintf(fp,"PD%d,%d;",x, y);
  789.     if(*micro488 != NULL)
  790.         fprintf(fp,"\n");
  791. }
  792.  
  793. /* PR - plot relative plotter units */
  794. void hpgl_plt_rel_pu(fp, x, y, micro488)
  795. FILE *fp;
  796. int x, y;
  797. char *micro488;
  798. {
  799.     rewind(fp);
  800.     if(*micro488 != NULL)
  801.         fprintf(fp,"%s",micro488);
  802.     fprintf(fp,"PR%d,%d;",x, y);
  803.     if(*micro488 != NULL)
  804.         fprintf(fp,"\n");
  805. }
  806.  
  807. /* PR - plot relative user units */
  808. void hpgl_plt_rel_uu(fp, x, y, micro488)
  809. FILE *fp;
  810. float x, y;
  811. char *micro488;
  812. {
  813.     rewind(fp);
  814.     if(*micro488 != NULL)
  815.         fprintf(fp,"%s",micro488);
  816.     fprintf(fp,"PR%.4f,%.4f;",x, y);
  817.     if(*micro488 != NULL)
  818.         fprintf(fp,"\n");
  819. }
  820.  
  821. /* PS - paper size, from Fujitsu FPG-310 manual */
  822. void hpgl_paper_size(fp, s, x, y, micro488)
  823. FILE *fp;
  824. int s, x, y;
  825. char *micro488;
  826. {
  827.     rewind(fp);
  828.     if(*micro488 != NULL)
  829.         fprintf(fp,"%s",micro488);
  830.     fprintf(fp,"PS%d,%d,%d;",s, x, y);
  831.     if(*micro488 != NULL)
  832.         fprintf(fp,"\n");
  833. }
  834.  
  835. /* PT - interval of line for hatching pattern, from Fujitsu FPG-310 manual */
  836. void hpgl_hatch_line_interval(fp, t, micro488)
  837. FILE *fp;
  838. float t;
  839. char *micro488;
  840. {
  841.     rewind(fp);
  842.     if(*micro488 != NULL)
  843.         fprintf(fp,"%s",micro488);
  844.     fprintf(fp,"PT%f;",t);
  845.     if(*micro488 != NULL)
  846.         fprintf(fp,"\n");
  847. }
  848.  
  849. /* PU - pen up */
  850. void hpgl_pen_up(fp, x, y, micro488)
  851. FILE *fp;
  852. int x, y;
  853. char *micro488;
  854. {
  855.     rewind(fp);
  856.     if(*micro488 != NULL)
  857.         fprintf(fp,"%s",micro488);
  858.     fprintf(fp,"PU%d,%d;",x, y);
  859.     if(*micro488 != NULL)
  860.         fprintf(fp,"\n");
  861. }
  862.  
  863. /* RA - absolute rectangle hatching, plotter units, 
  864.    from Fujitsu FPG-310 manual */
  865. void hpgl_rect_hatch_abs_pu(fp, x, y, micro488)
  866. FILE *fp;
  867. int x, y;
  868. char *micro488;
  869. {
  870.     rewind(fp);
  871.     if(*micro488 != NULL)
  872.         fprintf(fp,"%s",micro488);
  873.     fprintf(fp,"RA%d,%d;",x, y);
  874.     if(*micro488 != NULL)
  875.         fprintf(fp,"\n");
  876. }
  877.  
  878. /* RA - absolute rectangle hatching, user units, 
  879.    from Fujitsu FPG-310 manual */
  880. void hpgl_rect_hatch_abs_uu(fp, x, y, micro488)
  881. FILE *fp;
  882. float x, y;
  883. char *micro488;
  884. {
  885.     rewind(fp);
  886.     if(*micro488 != NULL)
  887.         fprintf(fp,"%s",micro488);
  888.     fprintf(fp,"RA%f,%f;",x, y);
  889.     if(*micro488 != NULL)
  890.         fprintf(fp,"\n");
  891. }
  892.  
  893. /* RC - read cursor, from hp9111a graphics tablet manual */
  894. void graph_tab_read_cursor(fp, x, y, pen, key, status, error, micro488)
  895. FILE *fp;
  896. int *x, *y, *pen, *key, *status, *error;
  897. char *micro488;
  898. {
  899.     char buf[80];
  900.     char enter488[10];
  901.  
  902.     rewind(fp);
  903.     if(*micro488 != NULL)
  904.         fprintf(fp,"%s",micro488);
  905.     fprintf(fp,"RC;");
  906.     if(*micro488 != NULL) {
  907.         out_enter(micro488, enter488);
  908.         fprintf(fp,"\n%s\n",enter488);
  909.     }
  910.     rewind(fp);
  911.     fgets(buf,80,fp);
  912.     sscanf(buf,"%d%*c%d%*c%d%*c%d%*c%d%*c%d%*c",x, y, pen, key, status, error);
  913. }
  914.  
  915. /* RO - rotate either 0 deg. or 90 deg., taken from Fujitsu FPG-310 manual */
  916. void hpgl_rotate(fp, a, micro488)
  917. FILE *fp;
  918. int a;
  919. char *micro488;
  920. {
  921.     rewind(fp);
  922.     if(*micro488 != NULL)
  923.         fprintf(fp,"%s",micro488);
  924.     fprintf(fp,"RO%d;",a);
  925.     if(*micro488 != NULL)
  926.         fprintf(fp,"\n");
  927. }
  928.  
  929. /* RR - relative rectangle hatching, plotter units, 
  930.    from Fujitsu FPG-310 manual */
  931. void hpgl_rect_hatch_rel_pu(fp, x, y, micro488)
  932. FILE *fp;
  933. int x, y;
  934. char *micro488;
  935. {
  936.     rewind(fp);
  937.     if(*micro488 != NULL)
  938.         fprintf(fp,"%s",micro488);
  939.     fprintf(fp,"RR%d,%d;",x, y);
  940.     if(*micro488 != NULL)
  941.         fprintf(fp,"\n");
  942. }
  943.  
  944. /* RR - relative rectangle hatching, user units, 
  945.    from Fujitsu FPG-310 manual */
  946. void hpgl_rect_hatch_rel_uu(fp, x, y, micro488)
  947. FILE *fp;
  948. float x, y;
  949. char *micro488;
  950. {
  951.     rewind(fp);
  952.     if(*micro488 != NULL)
  953.         fprintf(fp,"%s",micro488);
  954.     fprintf(fp,"RR%f,%f;",x, y);
  955.     if(*micro488 != NULL)
  956.         fprintf(fp,"\n");
  957. }
  958.  
  959. /* RS - read softkey, from hp9111a graphics tablet manual */
  960. int graph_tab_read_softkey(fp, menu_enable, micro488)
  961. FILE *fp;
  962. int menu_enable;
  963. char *micro488;
  964. {
  965.     char buf[80];
  966.     char enter488[10];
  967.     int key;
  968.  
  969.     rewind(fp);
  970.     if(*micro488 != NULL)
  971.         fprintf(fp,"%s",micro488);
  972.     fprintf(fp,"RS%d;",menu_enable);
  973.     if(*micro488 != NULL) {
  974.         out_enter(micro488, enter488);
  975.         fprintf(fp,"\n%s\n",enter488);
  976.     }
  977.     rewind(fp);
  978.     fgets(buf,80,fp);
  979.     sscanf(buf,"%d%*c",&key);
  980.     return(key);
  981. }
  982.     
  983. /* SC - scale */
  984. void hpgl_scale(fp, xmin, xmax, ymin, ymax, micro488)
  985. FILE *fp;
  986. int xmin, xmax, ymin, ymax;
  987. char *micro488;
  988. {
  989.     rewind(fp);
  990.     if(*micro488 != NULL)
  991.         fprintf(fp,"%s",micro488);
  992.     fprintf(fp,"SC%d,%d,%d,%d;", xmin, xmax, ymin, ymax);
  993.     if(*micro488 != NULL)
  994.         fprintf(fp,"\n");
  995. }
  996.  
  997. /* SI - absolute character size */
  998. void hpgl_abs_char_sz(fp, width, height, micro488)
  999. FILE *fp;
  1000. float width, height;
  1001. char *micro488;
  1002. {
  1003.     rewind(fp);
  1004.     if(*micro488 != NULL)
  1005.         fprintf(fp,"%s",micro488);
  1006.     fprintf(fp,"SI%f,%f;",width, height);
  1007.     if(*micro488 != NULL)
  1008.         fprintf(fp,"\n");
  1009. } 
  1010.  
  1011. /* SL - character slant */
  1012. void hpgl_char_sl(fp, tan, micro488)
  1013. FILE *fp;
  1014. float tan;
  1015. char *micro488;
  1016. {
  1017.     rewind(fp);
  1018.     if(*micro488 != NULL)
  1019.         fprintf(fp,"%s",micro488);
  1020.     fprintf(fp,"SL%f;",tan);
  1021.     if(*micro488 != NULL)
  1022.         fprintf(fp,"\n");
  1023. }
  1024.  
  1025. /* SM - symbol mode */
  1026. void hpgl_sym(fp, c, micro488)
  1027. FILE *fp;
  1028. char c;
  1029. char *micro488;
  1030. {
  1031.     rewind(fp);
  1032.     if(*micro488 != NULL)
  1033.         fprintf(fp,"%s",micro488);
  1034.     fprintf(fp,"SM%c;",c);
  1035.     if(*micro488 != NULL)
  1036.         fprintf(fp,"\n");
  1037. }
  1038.  
  1039. /* SP - pen select */
  1040. void hpgl_pen_sel(fp, pen, micro488)
  1041. FILE *fp;
  1042. int pen;
  1043. char *micro488;
  1044. {
  1045.     rewind(fp);
  1046.     if(*micro488 != NULL)
  1047.         fprintf(fp,"%s",micro488);
  1048.     fprintf(fp,"SP%d;",pen);
  1049.     if(*micro488 != NULL)
  1050.         fprintf(fp,"\n");
  1051. }
  1052.  
  1053. /* SR - relative character size */
  1054. void hpgl_char_sz(fp, width, height, micro488)
  1055. FILE *fp;
  1056. float width, height;
  1057. char *micro488;
  1058. {
  1059.     rewind(fp);
  1060.     if(*micro488 != NULL)
  1061.         fprintf(fp,"%s",micro488);
  1062.     fprintf(fp,"SR%f,%f;",width, height);
  1063.     if(*micro488 != NULL)
  1064.         fprintf(fp,"\n");
  1065. }
  1066.  
  1067. /* TL - tick length */
  1068. void hpgl_tick_len(fp, tp, tn, micro488)
  1069. FILE *fp;
  1070. float tp, tn;
  1071. char *micro488;
  1072. {
  1073.     rewind(fp);
  1074.     if(*micro488 != NULL)
  1075.         fprintf(fp,"%s",micro488);
  1076.     fprintf(fp,"TL%f,%f;",tp, tn);
  1077.     if(*micro488 != NULL)
  1078.         fprintf(fp,"\n");
  1079. }
  1080.  
  1081. /* UC - user defined character */
  1082. void hpgl_usr_char(fp, pen_control, x, y, num, micro488)
  1083. FILE *fp;
  1084. /* pen_control, x, y are arrays of float, num is the number of arrays */
  1085. float *pen_control, *x, *y; 
  1086. int num;
  1087. char *micro488;
  1088. {
  1089.     rewind(fp);
  1090.     if(*micro488 != NULL)
  1091.         fprintf(fp,"%s",micro488);
  1092.     fprintf(fp,"UC");
  1093.     if(*micro488 != NULL)
  1094.         fprintf(fp,"\n");
  1095.     while(num-- > 0) {
  1096.         if(*micro488 != NULL)
  1097.             fprintf(fp,"%s",micro488);
  1098.         fprintf(fp,"%f,%f,%f",*pen_control++, *x++, *y++);
  1099.         if(num > 0) 
  1100.             fprintf(fp,",");
  1101.         else
  1102.             fprintf(fp,";");
  1103.         if(*micro488 != NULL)
  1104.             fprintf(fp,"\n");
  1105.     }
  1106. }
  1107.  
  1108.  
  1109. /* VS - velocity select */
  1110. void hpgl_pen_vel(fp, pen_velocity, micro488)
  1111. FILE *fp;
  1112. float pen_velocity;
  1113. char *micro488;
  1114. {
  1115.     rewind(fp);
  1116.     if(*micro488 != NULL)
  1117.         fprintf(fp,"%s",micro488);
  1118.     fprintf(fp,"VS%f;",pen_velocity);
  1119.     if(*micro488 != NULL)
  1120.         fprintf(fp,"\n");
  1121. }
  1122.  
  1123. /* WG - wedge hatching,plotter units, from Fujitsu FPG-310 manual */
  1124. void hpgl_wedge_hatch_pu(fp, r, delta_theta, theta, phi, micro488)
  1125. FILE *fp;
  1126. int r, delta_theta, theta, phi;
  1127. char *micro488;
  1128. {
  1129.     rewind(fp);
  1130.     if(*micro488 != NULL)
  1131.         fprintf(fp,"%s",micro488);
  1132.     fprintf(fp,"WG%d,%d,%d,%d;",r, delta_theta, theta, phi);
  1133.     if(*micro488 != NULL)
  1134.         fprintf(fp,"\n");
  1135. }
  1136.  
  1137. /* WG - wedge hatching, user units, from Fujitsu FPG-310 manual */
  1138. void hpgl_wedge_hatch_uu(fp, r, delta_theta, theta, phi, micro488)
  1139. FILE *fp;
  1140. float r; 
  1141. int delta_theta, theta, phi;
  1142. char *micro488;
  1143. {
  1144.     rewind(fp);
  1145.     if(*micro488 != NULL)
  1146.         fprintf(fp,"%s",micro488);
  1147.     fprintf(fp,"WG%f,%d,%d,%d;",r, delta_theta, theta, phi);
  1148.     if(*micro488 != NULL)
  1149.         fprintf(fp,"\n");
  1150. }
  1151.  
  1152.  
  1153. /* RS-232-C COMMANDS                    */
  1154.  
  1155. /* set plotter configuration */
  1156. void serial_plot_config(fp, buf_size, handshake)
  1157. FILE *fp;
  1158. int buf_size, handshake;
  1159. {
  1160.     rewind(fp);
  1161.     fprintf(fp,"\033.@%d;%d:",buf_size, handshake);
  1162. }
  1163.  
  1164. /* output buffer space */
  1165. int serial_out_buffer_space(fp)
  1166. FILE *fp;
  1167. {
  1168.     char buf[80];
  1169.     int buf_space;
  1170.  
  1171.     rewind(fp);
  1172.     fprintf(fp,"\033.B");
  1173.     rewind(fp);
  1174.     fgets(buf,80,fp);
  1175.     sscanf(buf,"%d%*c",&buf_space);
  1176.     return(buf_space);
  1177. }
  1178.  
  1179. /* output extended error */
  1180. int serial_out_error(fp)
  1181. FILE *fp;
  1182. {
  1183.     char buf[80];
  1184.     int error;
  1185.  
  1186.     rewind(fp);
  1187.     fprintf(fp,"\033.E");
  1188.     rewind(fp);
  1189.     fgets(buf,80,fp);
  1190.     sscanf(buf,"%d%*c",&error);
  1191.     return(error);
  1192. }
  1193.  
  1194. /* set handshake mode 1 */
  1195. void serial_handshake_1(fp, c0, c1, num)
  1196. FILE *fp;
  1197. /* c1 is an integer array, num is the number of c1 arrays */
  1198. int c0, *c1;
  1199. int num;
  1200. {
  1201.     rewind(fp);
  1202.     fprintf(fp,"\033.H%d;",c0);
  1203.     while(num-- > 0) {
  1204.         fprintf(fp,"%d",*c1++);
  1205.         if(num > 0)
  1206.             fprintf(fp,";");
  1207.         else
  1208.             fprintf(fp,":");
  1209.     }
  1210. }
  1211.  
  1212. /* set handshake mode 2 */
  1213. void serial_handshake_2(fp, c0, c1, num)
  1214. FILE *fp;
  1215. /* c1 is a character array, num is the number of c1 arrays */
  1216. char c0, *c1;
  1217. int num;
  1218. {
  1219.     rewind(fp);
  1220.     fprintf(fp,"\033.I%d;",c0);
  1221.     while(num-- > 0) {
  1222.         fprintf(fp,"%c",*c1++);
  1223.         if(num > 0)
  1224.             fprintf(fp,";");
  1225.         else
  1226.             fprintf(fp,":");
  1227.     }
  1228. }
  1229.  
  1230. /* set output mode */
  1231. void serial_set_output(fp,t,c1,c2,c3,c4,c5)
  1232. FILE *fp;
  1233. unsigned int t;
  1234. int c1, c2, c3, c4, c5;
  1235. {
  1236.     rewind(fp);
  1237.     fprintf(fp,"\033.M%u;%d;%d;%d;%d;%d:",t, c1, c2, c3, c4, c5);
  1238. }
  1239.  
  1240. /* output extended status */
  1241. int serial_output_status(fp)
  1242. FILE *fp;
  1243. {
  1244.     char buf[80];
  1245.     int status;
  1246.  
  1247.     rewind(fp);
  1248.     fprintf(fp,"\033.O");
  1249.     rewind(fp);
  1250.     fgets(buf,80,fp);
  1251.     sscanf(buf,"%d%*c",&status);
  1252.     return(status);
  1253. }
  1254.     
  1255. /* set extended output and handshake mode */
  1256. void serial_ext_out_handshake(fp, t, c, num)
  1257. FILE *fp;
  1258. unsigned int t;
  1259. /* c is an array of integers, num is the number if c arrays */
  1260. int *c;
  1261. int num;
  1262. {
  1263.     rewind(fp);
  1264.     fprintf(fp,"\033.N%u;",t);
  1265.     while(num-- > 0) {
  1266.         fprintf(fp,"%d",*c);
  1267.         if(num > 0)
  1268.             fprintf(fp,";");
  1269.         else
  1270.             fprintf(fp,":");
  1271.     }
  1272. }
  1273.  
  1274. /* parse address from micro488 and follow ENTER in enter488 */
  1275. out_enter(micro488,enter488)
  1276. char *micro488, *enter488;
  1277. {
  1278.     int i;
  1279.  
  1280.     *enter488++ = 'E';
  1281.     *enter488++ = 'N';
  1282.     *enter488++ = 'T';
  1283.     *enter488++ = 'E';
  1284.     *enter488++ = 'R';
  1285.     for(i=0; i<6; i++) {
  1286.         ++micro488; /* point to first digit after OUTPUT */
  1287.     }
  1288.     /* copy address */
  1289.     for(i=0; i<2; i++) {
  1290.         *enter488++ = *micro488++;
  1291.     }
  1292.     *enter488 = NULL;
  1293. }
  1294.